package com.zhang.mapsort;

import java.util.*;

public class SortBByALinkedHashMap {
    public static void main(String[] args) {
        // 创建并初始化LinkedHashMap a（3个键值对）
        LinkedHashMap<String, String> a = new LinkedHashMap<>();
        a.put("k3", "a_val3");
        a.put("k1", "a_val1");
        a.put("k2", "a_val2");
        
        // 创建并初始化LinkedHashMap b（5个键值对，a的键都包含在b中）
        LinkedHashMap<String, String> b = new LinkedHashMap<>();
        b.put("k1", "val1");
        b.put("k2", "val2");
        b.put("k3", "val3");
        b.put("k4", "val4");  // a中没有的键
        b.put("k5", "val5");  // a中没有的键
        
        System.out.println("排序前的b: " + b);
        // 输出: 排序前的b: {k1=val1, k2=val2, k3=val3, k4=val4, k5=val5}
        
        // 按a的顺序排序b
        LinkedHashMap<String, String> sortedB = sortByAnotherMap(b, a);
        
        System.out.println("排序后的b: " + sortedB);
        // 输出: 排序后的b: {k3=val3, k1=val1, k2=val2, k4=val4, k5=val5}
    }
    
    /**
     * 按照另一个LinkedHashMap（orderMap）的键顺序排序当前LinkedHashMap（sourceMap）
     * 存在于orderMap中的键按其顺序排列，不存在的键排在末尾（保持原相对顺序）
     */
    public static <K, V> LinkedHashMap<K, V> sortByAnotherMap(
            LinkedHashMap<K, V> sourceMap, 
            LinkedHashMap<K, ?> orderMap) {
        
        // 获取orderMap（这里是a）的键顺序列表
        List<K> orderKeys = new ArrayList<>(orderMap.keySet());
        
        // 获取sourceMap（这里是b）的键并排序
        List<K> sourceKeys = new ArrayList<>(sourceMap.keySet());
        sourceKeys.sort((key1, key2) -> {
            int index1 = orderKeys.indexOf(key1);
            int index2 = orderKeys.indexOf(key2);
            
            // 处理排序逻辑
            if (index1 != -1 && index2 != -1) {
                // 两个键都在orderMap中，按orderMap的顺序排序
                return Integer.compare(index1, index2);
            } else if (index1 != -1) {
                // 只有key1在orderMap中，key1排在前面
                return -1;
            } else if (index2 != -1) {
                // 只有key2在orderMap中，key2排在前面
                return 1;
            } else {
                // 两个键都不在orderMap中，保持它们在sourceMap中的原有顺序
                return Integer.compare(sourceKeys.indexOf(key1), sourceKeys.indexOf(key2));
            }
        });
        
        // 按排序后的键构建新的LinkedHashMap
        LinkedHashMap<K, V> sortedMap = new LinkedHashMap<>();
        for (K key : sourceKeys) {
            sortedMap.put(key, sourceMap.get(key));
        }
        
        return sortedMap;
    }
}
    